/*Binary Search Tree <Template>
 *Recursive Version
 *relic@20070718
 *POJ2503Babelfish
 */

#include<cstdio>
#include<string>
using namespace std;

template <typename _Tp>
struct _node {
	_Tp data;
	_node * l, * r;
	_node(_Tp x, _node * a = NULL, _node * b = NULL) : data(x), l(a), r(b) {}
	_node(){}
};
template <typename _Tp>
struct BSTree {
	_node<_Tp> * root;
	BSTree() : root(NULL){}
	_node<_Tp> * findMin(_node<_Tp> * p);
	_node<_Tp> * findMax(_node<_Tp> * p);
	_node<_Tp> * removeMin(_node<_Tp> * & p);
	_node<_Tp> * BSTfind(const _Tp & x, _node<_Tp> * p);
	void BSTinsert(const _Tp & x, _node<_Tp> * & p);
	void BSTremove(const _Tp & x, _node<_Tp> * & p);
	void BSTclear(_node<_Tp> * & p);
	void insert(const _Tp & x);
	void remove(const _Tp & x);
	_Tp * find(const _Tp & x);
	void clear();
	void inorder(const _node<_Tp> * r);
};
template<typename _Tp>
_node<_Tp> * BSTree<_Tp>::findMin(_node<_Tp> * p) {
	while (p != NULL && p->l != NULL)
		p = p->l;
	return p;
}
template<typename _Tp>
_node<_Tp> * BSTree<_Tp>::findMax(_node<_Tp> * p) {
	while (p != NULL && p->r != NULL)
		p = p->r;
	return p;
}
template<typename _Tp>
_node<_Tp> * BSTree<_Tp>::removeMin(_node<_Tp> * & p) {
	if (p->l != NULL) {
		removeMin(p->l);
	} else {
		_node<_Tp> * tmp = p;
		p = p->r;
		delete tmp;
	}
}
template<typename _Tp>
void BSTree<_Tp>::BSTinsert(const _Tp & x, _node<_Tp> * & p) {
	if (p == NULL)
		p = new _node<_Tp>(x);
	else if (x < p->data)
		BSTinsert(x, p->l);
	else
		BSTinsert(x, p->r);
}
template<typename _Tp>
_node<_Tp> * BSTree<_Tp>::BSTfind(const _Tp & x, _node<_Tp> * p) {
	if (p == NULL)
		return NULL;
	else if (p->data == x)
		return p;
	else if (x < p->data)
		return BSTfind(x, p->l);
	else
		return BSTfind(x, p->r);
}
template<typename _Tp>
void BSTree<_Tp>::BSTremove(const _Tp & x, _node<_Tp> * & p) {
	if (p == NULL) {
		return ;
	} else if (x < p->data) {
		BSTremove(x, p->l);
	} else if (p->data < x) {
		BSTremove(x, p->r);
	} else if (p->l != NULL && p->r != NULL) {
		p->data = findMin(p->r)->data;
        removeMin(p->r);
	} else {
		_node<_Tp> * tmp = p;
		p = p->l ? p->l : p->r;
		delete tmp;
	}
}
template<typename _Tp>
void BSTree<_Tp>::BSTclear(_node<_Tp> * & p) {
	if (p != NULL) {
		BSTclear(p->l);
		BSTclear(p->r);
		delete p;
	}
	p = NULL;
}
template<typename _Tp>
void BSTree<_Tp>::insert(const _Tp & x) {
	BSTinsert(x, root);
}
template<typename _Tp>
void BSTree<_Tp>::remove(const _Tp & x) {
	BSTremove(x, root);
}
template<typename _Tp>
_Tp * BSTree<_Tp>::find(const _Tp & x) {
	_node<_Tp> *p = BSTfind(x, root);
	return p != NULL ? &p->data : NULL;
}
template<typename _Tp>
void BSTree<_Tp>::clear() {
	BSTclear(root);
}
template<typename _Tp>
void BSTree<_Tp>::inorder(const _node<_Tp> * r) {
	if(r == NULL)
		return ;
	else {
		inorder(r->l);
		printf("%d -> %d -> %d\n", r->data, r->l ? r->l->data : 0, r->r ? r->r->data : 0);
		inorder(r->r);
	}
}

struct entry {
	string a, b;
	entry(string &x, string &y) : a(x), b(y){}
	bool operator<(const entry &x) const {
		return a < x.a;
	}
	bool operator==(const entry &x) const {
		return a == x.a;
	}
};
int main() {
	char s[30], *p;
	char delim[] = " /";
	BSTree<entry> bst;
	while (gets(s)) {
		if (s[0] == '\0') break;
		p=strtok(s,delim);
		string a(p);
		p=strtok(NULL,delim);
		string b(p);
		bst.insert(entry(b, a));
	}
	string sss;
	while (scanf("%s", s) != EOF) {
		string a(s);
		entry *p = bst.find(entry(a, sss));
		if (p != NULL)
			printf("%s\n", p->b.c_str());
		else
			printf("eh\n");
	}
	bst.clear();
	return 0;
}
